home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / xwindows / demos / xfract_1.z / xfract_1 / xfractint-1.06 / jb.c < prev    next >
C/C++ Source or Header  |  1992-09-28  |  14KB  |  437 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include "fractint.h"
  4. #include "mpmath.h"
  5. #include "helpdefs.h"
  6. #include "prototyp.h"
  7.  
  8. extern int row, col, xdots, ydots, bitshift, fractype;
  9. extern int ixstart, ixstop, iystart, iystop, colors, helpmode;
  10. extern double param[], xxmin, xxmax, yymin, yymax;
  11. extern long delx, dely, ltempsqrx, ltempsqry, far *lx0, far *ly0;
  12. extern double tempsqrx, tempsqry;
  13. extern struct lcomplex lold, lnew, *longparm;
  14. extern struct complex old, new, *floatparm;
  15. extern llimit2;
  16. static int bbase;
  17. static long xpixel, ypixel;
  18. static double xpixelfp, ypixelfp;
  19. static long initz, djx, djy, dmx, dmy;
  20. static double initzfp, djxfp, djyfp, dmxfp, dmyfp;
  21. static long jx, jy, mx, my, xoffset, yoffset;
  22. static double jxfp, jyfp, mxfp, myfp, xoffsetfp, yoffsetfp;
  23. static long jxmin, jxmax, jymin, jymax, mxmin, mxmax, mymin, mymax;
  24. static double jxminfp, jxmaxfp, jyminfp, jymaxfp, mxminfp, mxmaxfp, myminfp,
  25.     mymaxfp;
  26. static long x_per_inch, y_per_inch, inch_per_xdot, inch_per_ydot;
  27. static double x_per_inchfp, y_per_inchfp, inch_per_xdotfp, inch_per_ydotfp;
  28. struct Perspective {
  29.    long x, y, zx, zy;
  30. };
  31.  
  32. struct Perspectivefp {
  33.    double x, y, zx, zy;
  34. };
  35.  
  36. struct Perspective LeftEye, RightEye, *Per;
  37. struct Perspectivefp LeftEyefp, RightEyefp, *Perfp;
  38. struct lcomplex jbc;
  39. struct complex jbcfp;
  40.  
  41. static char StereoFile[] = "glasses1.map";
  42. static char GreyFile[] = "altern.map";
  43.  
  44. #define NUM_VAR 17
  45.  
  46. static char far v0[] = {"Julia from x"};
  47. static char far v1[] = {"Julia to x"};
  48. static char far v2[] = {"Julia from y"};
  49. static char far v3[] = {"Julia to y"};
  50. static char far v4[] = {"Mandelbrot from x"};
  51. static char far v5[] = {"Mandelbrot to x"};
  52. static char far v6[] = {"Mandelbrot from y"};
  53. static char far v7[] = {"Mandelbrot to y"};
  54. static char far v8[] = {"Number of z pixels"};
  55. static char far v9[] = {"Penetration level"};
  56. static char far v10[] = {"Location of z origin"};
  57. static char far v11[] = {"Depth of z"};
  58. static char far v12[] = {"Screen height"};
  59. static char far v13[] = {"Screen width"};
  60. static char far v14[] = {"Distance to Screen"};
  61. static char far v15[] = {"Distance between eyes (0 for Greyscale)"};
  62. static char far v16[] = {"Blue:Red Ratio (0 for Greyscale)"};
  63. static char far *v[NUM_VAR] = {v0,v1,v2,v3,v4,v5,v6,v7,v8,v9,
  64.     v10,v11,v12,v13,v14,v15,v16};
  65.  
  66. static double fg, fg16;
  67. static long
  68.         zdots = 128L,
  69.         shell = 30L,
  70.         origin = (long)(8.0 * (1L << 16)),
  71.    height = (long)(7.0 * (1L << 16)),
  72.         width = (long)(10.0 * (1L << 16)),
  73.    dist = (long)(24.0 * (1L << 16)),
  74.    eyes = (long)(0.0 * (1L << 16)),
  75.    depth = (long)(8.0 * (1L << 16)),
  76.    brratio = (long)(0.0 * (1L << 16));
  77.  
  78. double originfp=8, heightfp=7, widthfp=10, distfp=24, eyesfp=0, depthfp=8,
  79.     brratiofp=0;
  80.  
  81. int JulibrotSetup(void) {
  82.         int r;
  83.         int oldhelpmode;
  84.    struct fullscreenvalues d[NUM_VAR];
  85.    char *mapname;
  86.  
  87.    if(colors < 255) {
  88.       static char far msg[]=
  89.           {"Sorry, but Julibrots require a 256-color video mode"};
  90.       stopmsg(0,msg);
  91.       return(0);
  92.    }
  93.  
  94.    fg = (double)(1L << bitshift);
  95.    fg16 = (double)(1L << 16);
  96.  
  97.    for (r = 0; r < NUM_VAR; ++r)
  98.       d[r].type = 'f';
  99.  
  100.         jxmaxfp = (long)((d[0].uval.dval = xxmax) * fg);
  101.         jxminfp = (long)((d[1].uval.dval = xxmin) * fg);
  102.         jymax = (long)((d[2].uval.dval = yymax) * fg);
  103.         jymin = (long)((d[3].uval.dval = yymin) * fg);
  104.         mxmax = (long)((d[4].uval.dval = param[0]) * fg);
  105.         mxmin = (long)((d[5].uval.dval = param[1]) * fg);
  106.         mymax = (long)((d[6].uval.dval = param[2]) * fg);
  107.         mymin = (long)((d[7].uval.dval = param[3]) * fg);
  108.    d[8].uval.dval = (double)zdots;
  109.    d[9].uval.dval = (double)shell;
  110.    d[10].uval.dval = (double)origin / fg16;
  111.    d[11].uval.dval = (double)depth / fg16;
  112.    d[12].uval.dval = (double)height / fg16;
  113.    d[13].uval.dval = (double)width / fg16;
  114.    d[14].uval.dval = (double)dist / fg16;
  115.    d[15].uval.dval = (double)eyes / fg16;
  116.    d[16].uval.dval = (double)brratio / fg16;
  117.  
  118.    stackscreen();
  119.    oldhelpmode = helpmode;
  120.    helpmode = HT_JULIBROT;
  121.    if((r = fullscreen_prompt("Julibrot Parameters",
  122.                               NUM_VAR, v, d, 0, 0, 0)) >= 0) {
  123.       jxmin = (long)((xxmax = d[0].uval.dval) * fg);
  124.       jxmax = (long)((xxmin = d[1].uval.dval) * fg);
  125.       xoffset = (jxmax + jxmin) / 2;       /* Calculate average */
  126.       jymin = (long)((yymax = d[2].uval.dval) * fg);
  127.       jymax = (long)((yymin = d[3].uval.dval) * fg);
  128.       yoffset = (jymax + jymin) / 2;       /* Calculate average */
  129.       mxmin = (long)((param[0] = d[4].uval.dval) * fg);
  130.       mxmax = (long)((param[1] = d[5].uval.dval) * fg);
  131.       mymin = (long)((param[2] = d[6].uval.dval) * fg);
  132.       mymax = (long)((param[3] = d[7].uval.dval) * fg);
  133.       zdots = (long)(d[8].uval.dval);
  134.       shell = (long)(d[9].uval.dval);
  135.       origin = (long)(d[10].uval.dval * fg16);
  136.       depth = (long)(d[11].uval.dval * fg16);
  137.       height = (long)(d[12].uval.dval * fg16);
  138.       width = (long)(d[13].uval.dval * fg16);
  139.       dist = (long)(d[14].uval.dval * fg16);
  140.       eyes = (long)(d[15].uval.dval * fg16);
  141.       brratio = (long)(d[16].uval.dval * fg16);
  142.       dmx = (mxmax - mxmin) / zdots;
  143.       dmy = (mymax - mymin) / zdots;
  144.       longparm = &jbc;
  145.  
  146.       x_per_inch = (long)((d[1].uval.dval - d[0].uval.dval) / d[13].uval.dval * fg);
  147.       y_per_inch = (long)((d[3].uval.dval - d[2].uval.dval) / d[12].uval.dval * fg);
  148.                 inch_per_xdot = (long)(d[13].uval.dval / xdots * fg16);
  149.                 inch_per_ydot = (long)(d[12].uval.dval / ydots * fg16);
  150.       initz = origin - (depth / 2);
  151.       LeftEye.x = -(RightEye.x = eyes / 2);
  152.       LeftEye.y = RightEye.y = 0l;
  153.       LeftEye.zx = RightEye.zx = dist;
  154.       LeftEye.zy = RightEye.zy = dist;
  155.       bbase = (int)(128.0 * d[16].uval.dval);
  156.    }
  157.  
  158.    helpmode = oldhelpmode;
  159.    unstackscreen();
  160.  
  161.    if(d[16].uval.dval == 0.0)
  162.       mapname = GreyFile;
  163.    else
  164.       mapname = StereoFile;
  165.    if (ValidateLuts(mapname) != 0)
  166.       return(0);
  167.    spindac(0,1);                 /* load it, but don't spin */
  168.  
  169.    return(r >= 0);
  170. }
  171.  
  172. int JulibrotfpSetup(void) {
  173.         int r;
  174.         int oldhelpmode;
  175.    struct fullscreenvalues d[NUM_VAR];
  176.    char *mapname;
  177.  
  178.    if(colors < 255) {
  179.       static char far msg[]=
  180.           {"Sorry, but Julibrots require a 256-color video mode"};
  181.       stopmsg(0,msg);
  182.       return(0);
  183.    }
  184.  
  185.    for (r = 0; r < NUM_VAR; ++r)
  186.       d[r].type = 'f';
  187.  
  188.         jxmaxfp = d[0].uval.dval = xxmax;
  189.         jxminfp = d[1].uval.dval = xxmin;
  190.         jymaxfp = d[2].uval.dval = yymax;
  191.         jyminfp = d[3].uval.dval = yymin;
  192.         mxmaxfp = d[4].uval.dval = param[0];
  193.         mxminfp = d[5].uval.dval = param[1];
  194.         mymaxfp = d[6].uval.dval = param[2];
  195.         myminfp = d[7].uval.dval = param[3];
  196.    d[8].uval.dval = (double)zdots;
  197.    d[9].uval.dval = (double)shell;
  198.    d[10].uval.dval = originfp;
  199.    d[11].uval.dval = depthfp;
  200.    d[12].uval.dval = heightfp;
  201.    d[13].uval.dval = widthfp;
  202.    d[14].uval.dval = distfp;
  203.    d[15].uval.dval = eyesfp;
  204.    d[16].uval.dval = brratiofp;
  205.  
  206.    stackscreen();
  207.    oldhelpmode = helpmode;
  208.    helpmode = HT_JULIBROT;
  209.    if((r = fullscreen_prompt("Julibrot Parameters",
  210.                               NUM_VAR, v, d, 0, 0, 0)) >= 0) {
  211.       jxminfp = xxmax = d[0].uval.dval;
  212.       jxmaxfp = xxmin = d[1].uval.dval;
  213.       xoffsetfp = (jxmaxfp + jxminfp) / 2;       /* Calculate average */
  214.       jyminfp = yymax = d[2].uval.dval;
  215.       jymaxfp = yymin = d[3].uval.dval;
  216.       yoffsetfp = (jymaxfp + jyminfp) / 2;       /* Calculate average */
  217.       mxminfp = param[0] = d[4].uval.dval;
  218.       mxmaxfp = param[1] = d[5].uval.dval;
  219.       myminfp = param[2] = d[6].uval.dval;
  220.       mymaxfp = param[3] = d[7].uval.dval;
  221.       zdots = (long)(d[8].uval.dval);
  222.       shell = (long)(d[9].uval.dval);
  223.       originfp = d[10].uval.dval;
  224.       depthfp = d[11].uval.dval;
  225.       heightfp = d[12].uval.dval;
  226.       widthfp = d[13].uval.dval;
  227.       distfp = d[14].uval.dval;
  228.       eyes = d[15].uval.dval;
  229.       brratio = d[16].uval.dval;
  230.       dmxfp = (mxmaxfp - mxminfp) / zdots;
  231.       dmyfp = (mymaxfp - myminfp) / zdots;
  232.       floatparm = &jbcfp;
  233.  
  234.       x_per_inchfp = (d[1].uval.dval - d[0].uval.dval) /